# 委托
# 委托delegate
public delegate void mydelegate();//定义了一个mydelegate的类型 ,用来保存方法
mydelegate md=new mydelegate（方法名） 存一个方法
md（） 调一下委托
1.是一种数据类型，一般在命名空间中定义
2.定义委托时，需要指定返回值类型，委托名和参数名
3.委托是引用类型，就像类一样，所以委托声明后，如果不赋值变量为null，所以在使用委托变量前最好使用非空校验！=null ?.
4.委托类型的变量只能赋值一个委托类型的对象
mydelegate md=new mydelegate(M1)
mydelegate md=M1
5.md.invoke()调用
1
2
3
4
5
6
7
8
9
10
2
3
4
5
6
7
8
9
10
# 泛型委托：
无返回值
action
action<T>
有返回值
func<T> 只有泛型版本的
//保存无参数无返回值得方法
action action=new action()
action()
public delegate void action <T1,T2,T3>()
action<string> a1=m=>{console.write()}
action<string,,int> a1=m=>{console.write()}
public delegate Tresult func<T1,T2,T3,Tresult>()
func<int,int,int> fun=(m,n)=>{return m+n}
int f=fun(m,n)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 多播委托
一个委托可以储存多个方法
第一个要=赋值，后面的+=赋值
action<string> action=m1
action+=m2
action+=m3
action+=m4
action-=m3
action("aaaa")
delegate my=new delegate(t1);
md=delegate.combine(md,new mydelegate(T2))
md()
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
# 匿名方法,lambda表达式
匿名方法
mydelegate md=delegate（）{console.write()}
lambda:不用传数据类型
mydelegate md=()=>{console.write()}
mydelegate md=m=>{console.write(m)}
mydelegate md=(m,n)=>{console.write("m"+"n")}
1
2
3
4
5
6
7
2
3
4
5
6
7
# 事件
事件基于委托
只能-=，+=
public event action test；
声明委托和事件特别像，就是加一个event
因为委托来实现外部可以随便调用，不能将委托变成pirvate，也就无法调用
委托可以=赋值一旦=null，就全部取消掉了
事件编译就是私有的委托，但加了add和remove两个共有的方法
1
2
3
4
5
6
7
8
9
2
3
4
5
6
7
8
9
# 反射
动态加载程序集中的元数据，获取其类型，获取其属性，方法，来操作,(智能提示)
type mytype=typeof(my)
fieldinfo[] fields=mytype.getfields();获取字段
getmenber()获取成员
getevent()获取事件
getmethod()获取方法…………
拿到type有很多操作，可以获取很多
1
2
3
4
5
6
7
2
3
4
5
6
7
动态加载程序集
assembly ass=assembly.loadfile(@"路径")；
获取说有程序集中的类型
type[] types=asm.gettypes()//获取所有类型
.getexportedtypes()//获取所有public类型
type typeperson=asm.gettypes(types[0])//获取第一个类型下所有类型
methodinfo method=typeperson.getmethod("方法名")获取方法
method.invoke(对象，参数)
无参
activator.createinstance（typeperson）//创建实例
有参
constructorinfo ci= typeperson.getconstructor(new type[]{typeof(string),typeof(string)}})
ci.invoke(new object[]{"zzzz","aaa"});
获取属性值
propertyinfo pinfo=typeperson.getproperty("name");
string a=pinfo.getvalue(object,null)
b.isassignablefrom(a) 类型检验 a能否赋值给b 父子类关系
a.issubclassf(b) 同上 与接口无关
.isinstanceoftype() 实例检验 父子类关系
.isabstract（） 判断是否抽象类，接口，静态类（不能实例化的）
反射获取私有方法
methodinfo method=typeperson.getmethod("方法名"，bindingflags.nopublic|bindingflags.instance)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# 枚举
==没加[flags]显示数字==
==加[flags]显示枚举类型==
enum枚举
标志枚举[flags]不互斥
[Flags]
public enum Permission
{
create = 1,
read = 2,
update = 4,
delete = 8,
}
static void Main(string[] args)
{
Permission permission = Permission.create | Permission.read | Permission.update | Permission.delete;
Console.WriteLine("1、枚举创建，并赋值……");
Console.WriteLine(permission.ToString());
Console.WriteLine((int)permission);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 扩展方法
1.静态类、静态方法以及this关键字。
2.无法访问类的私有成员
3.静态类和类要同一个空间，否则要引用
public class person
{
public void say()
{}
}
public static class person
{
public static void say(this person p)
{
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
2
3
4
5
6
7
8
9
10
11
12
13
14